Nginx 负载-代理-缓存配置

发表于 | 更新于 | 分类于 ，
nginx http 里负载配置
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

mkdir -p /etc/nginx/http.d

cat > /etc/nginx/http.d/20.upstream.conf << EOF

upstream images {

    server 200.200.200.222:99 weight=5 max_fails=3 fail_timeout=60s;
    server 200.200.200.223:99 weight=5 max_fails=3 fail_timeout=60s;
    # server 200.200.200.225:99 weight=5 backup;
    # server unix:/tmp/backend3; #使用unix socket
    # keepalive 32;
}

EOF
nginx server 代理配置
1
2
3
4
5
6
7
8
9

location ~ .*\.(mp4|gif|jpg|jpeg|png|bmp|swf|js|css)$
{
        ## 指定访问后端服务器的IP地址
        #proxy_bind 127.0.0.1;
        proxy_pass $scheme://images;
        include local.d/proxy.conf;
        proxy_next_upstream http_404;
}

代理参数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

mkdir -p /etc/nginx/local.d

cat > /etc/nginx/local.d/proxy.conf << EOF

#proxy_next_upstream http_404
proxy_redirect              off;

proxy_set_header            Host \$host;
proxy_set_header            X-Real-IP \$remote_addr;
proxy_set_header            X-Forwarded-For \$proxy_add_x_forwarded_for;

proxy_set_header            Accept-Encoding 'gzip';

client_max_body_size        100m;
client_body_buffer_size     256k;

proxy_connect_timeout       60;
proxy_send_timeout          60;
proxy_read_timeout          60;

proxy_buffer_size           512k;
proxy_buffers               8 512k;
proxy_busy_buffers_size     512k;
proxy_temp_file_write_size  512k;

EOF

upstream

调度算法

默认round robin 随机负载。

1. ip_hash  

    源地址hash调度方法,可用位置:upstream

    指定一个使用负载均衡方法根据客户端 IP 地址将请求分发给一些服务器的群。

    客户 IPv4 地址或者 IPv6 地址的前三个位群作为一个散列键。

    这个方法可以使同一个客户端的常常被发送给同一台主机，除非这台主机是不可用状态。

    在这种情况下(该主机不可用)客户端请求会被传递到另一台主机。大多数情况下，它将被发送给同一台主机。

    Nginx 1.3.2 和 1.2.2 之后开始支持 IPv6 地址。

    如果服务器中的一台需要临时移除掉，那么它应该使用 down 参数标记以保持客户 IP 地址的当前散列。

    在 Nginx 1.3.1 和 1.2.2 版本之前的版本是无法使用 ip_hash 负载均衡方式定义服务器权重的。

2. least_conn 

    最少连接调度算法，当server拥有不同的权重时其为wlc，当所有后端主机连接数相同时，则使用wrr，适用于长连接

    定义一群应该在请求传递给具有最小有效连接的服务器时使用的负载均衡方法，要考虑到服务器的权重。如果有很多这样的服务器，将会使用带权重的 round-robin 方法。

3. hash key [consistent] 
    基于指定的key的hash表来实现对请求的调度，此处的key可以直接文本、变量或二者组合 
    可用位置:upstream
        作用：将请求分类，同一类请求将发往同一个upstream server，使用consistent参数，将使用ketama一致性hash算法，适用于后端是Cache服务器（如varnish）时使用 
        hash $request_uri consistent;  #根据url
        hash $remote_addr;             #根据请求的主机

server 配置

语法：server address [parameters]; 

    在upstream上下文中server成员，以及相关的参数； 

    可用位置:upstream 

    address的表示格式：
        unix:/PATH/TO/SOME_SOCK_FILE 
        IP[:PORT] 
        HOSTNAME[:PORT] 

    parameters： 
        weight=number     #权重，默认为1 
        max_conns         #连接后端报务器最大并发活动连接数，1.11.5后支持 
        max_fails=number  #失败尝试最大次数；超出此处指定的次数时，server将被标记为不可用,默认为1 
        fail_timeout=time #后端服务器标记为不可用状态的连接超时时长，默认10s 
        backup            #将服务器标记为“备用”，即所有服务器均不可用时才启用 
        down              #标记为“不可用”，配合ip_hash使用，实现灰度发布


可设置参数为：

1. weight=number ：

        默认为1，weight越大，负载的权重就越大。

2. max_fails=number ：

        设置由 fail_timeout 定义的时间段内连接该主机的失败次数，以此来断定 fail_timeout 定义的时间段内该主机是否可用。

        默认情况下这个数值设置为 1。零值的话禁用这个数量的尝试。

        当超过最大次数时，返回proxy_next_upstream模块定义的错误。

        由proxy_next_upstream、fastcgi_next_upstream、以及memcached_next_upstream 等指令来判定错误尝试。

        如果群里面只有一台主机，那么 max_fails、 fail_timeout 和 slow_start 参数将被忽略，而且这样的主机也永远不会被认为不可用。


3. fail_timeout=time ：

        设置
        在指定时间内连接到主机的失败次数，超过该次数该主机被认为不可用。
        服务器被视为无效的时段。
        这个参数默认是 10 秒钟。

        fail_timeout 的默认值是 10 秒，配合默认值为 1 的 max_fails 参数，意思是如果在 fail_timeout 期间后端失败了 max_fails 次，那么就将这个后端标识为不可用，在接下来的 fail_timeout 期间， NGINX 不会再将请求分配到这个后端。

        如果将 fail_timeout 设置为 0 ，那么无论后端失败了多少次， NGINX 会继续把请求分发到这个后端服务器地址。

        在动态应用中，出现偶尔的 500 错误是很正常而且几乎无法避免的。如果后端因为某些更严重的原因一直出现 500 错误，那nginx upstream 的自动剔除该服务器。

        fail_timeout 设置为 10 秒或者更长时间，可能对于静态的后端会更有意义。因为静态的后端通常很难出现 500 错误。如果出错了，一般也都是因为一些更麻烦的问题，比如硬盘坏了，或者内存满了之类

        1. 假如 upstream 只有一个 server ，那 max_fails 和 fail_timeout 都是没用的。

        2. 假如 upstream 有多个 server ，那超过了 max_fails 次错误后，在 fail_timeout 时间内会摘除这个 server。如果全部 server 都失败， nginx 会清空这个状态，轮询所有服务器 

4. backup：将当前服务器标记为备份服务器。当主服务器不可用时，向备用服务器传递请求。

5. down：  标记当前服务器为不可用；和 ip_hash 指令一起使用。

6. slow_start=time ：

        设置一台不健康的主机变成健康主机，或者当一台主机在被认为不可用变成可用时，将其权重由零恢复到标称值的时间。
        默认值为零，也就是说，禁用慢启动。
        这个功能仅作为我们的商业订阅的一部分。

keepalive

语法：keepalive connections;

激活 upstream 服务器的连接缓存。

connections 参数设置保存在每个工作进程缓存中的 upstream 主机的闲置 keepalive 连接的最大个数。

超出这个数目时，最近很少使用的连接被关闭。

keepalive 指令并没有限制一个 Nginx 工作进程所能承载的连接总量。

connections 应该设置为一个足够小的值以使 upstream 服务器也足以应对新的连接。

用 http 1.1 和 connection keep-alive 可以提高效率。

nginx 默认给 upstream 是 connection: close

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

## 带有 keepalive 连接的 memcached upstream 配置例子：

upstream memcached_backend {
    server 127.0.0.1:11211;
    server 10.0.0.2:11211;

    keepalive 32;
}

server {
    ...

    location /memcached/ {
        set $memcached_key $uri;
        memcached_pass memcached_backend;
    }

}
对于 HTTP，proxy_http_version 指令应该设置为 "1.1"，并且清空 "Connection" 头字段：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

upstream http_backend {
    server 127.0.0.1:8080;

    keepalive 16;
}

server {
    ...

    location /http/ {
        proxy_pass http://http_backend;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
        ...
    }
}
对于 FastCGI 服务器，需要为持久连接设置 fastcgi_keep_conn：

当使用 round-robin 之外的负载均衡方法时，需要在 keepalive 指令之前将他们激活。

SCGI 和 uwsgi 协议没有长连接的概念。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

upstream fastcgi_backend {
    server 127.0.0.1:9000;

    keepalive 8;
}

server {
    ...

    location /fastcgi/ {
        fastcgi_pass fastcgi_backend;
        fastcgi_keep_conn on;
        ...
    }
}

Nginx Proxy 代理图片静态文件缓存配置

图片服务器使用 Nginx 的 proxy_store 把主服务器的静态内容缓存到本地。
一次访问结束后，以后的访问将直接在本地硬盘上读写。从而分担流量负载

    server {
        include         listen.conf;
        server_name     ucenter.gznow.org;

        location ~ \.php$ {
            limit_conn   one  20;
            limit_rate   50k;
            proxy_pass http://s1;
            include proxy.conf;
        }

        location / {
            expires max;
            root /data/nginx_cache/ucenter;
            proxy_store on;
            proxy_store_access user:rw group:rw all:rw;
            proxy_temp_path /data/nginx_cache/ucenter;

            include local.d/proxy.conf;
            #proxy_bind 127.0.0.1;
            proxy_next_upstream http_404;

            if ( !-e $request_filename) {
            proxy_pass $scheme://images;

            }
        }
}

缓存模板

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

http{

    proxy_cache_path /var/cache/nginx/proxy_cache levels=1:2:2 keys_zone=proxycache:20m inactive=120s max_size=1g;
    
    upstream mysqlsrvs{
        ip_hash; #源地址hash调度方法 写了backup就不可用
        server 172.18.99.1:80 weight=2; #weight权重
        server 172.18.99.2:80;          #标记down，配合ip_hash使用，实现灰度发布
        server 172.18.99.3:80 backup;   #backup将服务器标记为“备用”，即所有服务器均不可用时才启用 
    }

}

server{
    server_name www.a.com;
    proxy_cache proxycache;
    proxy_cache_key $request_uri;
    proxy_cache_valid 200 302 301 1h;
    proxy_cache_valid any 1m;
    location / {
        proxy_pass http://mysqlsrvs;
    }
}

Haproxy做代理,后端nginx获取真实用户IP

1）修改haproxy配置文件,添加如下参数:

option httpclose
option forwardfor

2）修改nginx配置文件,添加如下参数 注意:需要编译模块--with-http_realip_module

#haproxy服务器IP
set_real_ip_from  192.168.64.128;
real_ip_header    X-Forwarded-For;
real_ip_recursive on;

3）分别重启haproxy和nginx

upstreem 第三方check模块

cd /opt

yum install unzip

wget https://github.com/yaoweibin/nginx_upstream_check_module/archive/master.zip

wget http://nginx.org/download/nginx-1.14.0.tar.gz

tar -zxf nginx-1.14.0.tar.gz

unzip master.zip


cd /opt/nginx-1.14.0/

## 给nginx打上补丁
patch -p1 < /opt/nginx_upstream_check_module-master/check_1.12.1+.patch

## 配置
./configure --add-module=/opt/nginx_upstream_check_module-master --prefix=/etc/nginx --sbin-path=/usr/sbin/nginx --modules-path=/usr/lib64/nginx/modules --conf-path=/etc/nginx/nginx.conf --error-log-path=/var/log/nginx/error.log --http-log-path=/var/log/nginx/access.log --pid-path=/var/run/nginx.pid --lock-path=/var/run/nginx.lock --http-client-body-temp-path=/var/cache/nginx/client_temp --http-proxy-temp-path=/var/cache/nginx/proxy_temp --http-fastcgi-temp-path=/var/cache/nginx/fastcgi_temp --http-uwsgi-temp-path=/var/cache/nginx/uwsgi_temp --http-scgi-temp-path=/var/cache/nginx/scgi_temp --user=nginx --group=nginx --with-compat --with-file-aio --with-threads --with-http_addition_module --with-http_auth_request_module --with-http_dav_module --with-http_flv_module --with-http_gunzip_module --with-http_gzip_static_module --with-http_mp4_module --with-http_random_index_module --with-http_realip_module --with-http_secure_link_module --with-http_slice_module --with-http_ssl_module --with-http_stub_status_module --with-http_sub_module --with-http_v2_module --with-mail --with-mail_ssl_module --with-stream --with-stream_realip_module --with-stream_ssl_module --with-stream_ssl_preread_module --with-cc-opt='-O2 -g -pipe -Wall -Wp,-D_FORTIFY_SOURCE=2 -fexceptions -fstack-protector-strong --param=ssp-buffer-size=4 -grecord-gcc-switches -m64 -mtune=generic -fPIC' --with-ld-opt='-Wl,-z,relro -Wl,-z,now -pie'


make && make install
配置样本
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

http {

    upstream cluster {

        # simple round-robin
        server 192.168.0.1:80;
        server 192.168.0.2:80;

        check interval=5000 rise=1 fall=3 timeout=4000;

        #check interval=3000 rise=2 fall=5 timeout=1000 type=ssl_hello;

        #check interval=3000 rise=2 fall=5 timeout=1000 type=http;
        #check_http_send "HEAD / HTTP/1.0\r\n\r\n";
        #check_http_expect_alive http_2xx http_3xx;
    }

    server {
        listen 80;

        location / {
            proxy_pass http://cluster;
        }

        location /status {
            check_status;

            access_log   off;
            allow SOME.IP.ADD.RESS;
            deny all;
       }
    }

}
参数：

check

    syntax: *check interval=milliseconds [fall=count] [rise=count]
    [timeout=milliseconds] [default_down=true|false]
    [type=tcp|http|ssl_hello|mysql|ajp|fastcgi]*

    default: *none, if parameters omitted, default parameters are
    interval=30000 fall=5 rise=2 timeout=1000 default_down=true type=tcp*



check_http_send

    syntax: *check_http_send http_packet*

    default: *"GET / HTTP/1.0\r\n\r\n"*

    context: *upstream*

    description: If you set the check type is http, then the check function
    will sends this http packet to check the upstream server.

check_http_expect_alive

    syntax: *check_http_expect_alive [ http_2xx | http_3xx | http_4xx |
    http_5xx ]*

    default: *http_2xx | http_3xx*

    context: *upstream*

    description: These status codes indicate the upstream server's http
    response is ok, the backend is alive.

check_keepalive_requests

    syntax: *check_keepalive_requests num*

    default: *check_keepalive_requests 1*

    context: *upstream*

    description: The directive specifies the number of requests sent on a
    connection, the default vaule 1 indicates that nginx will certainly
    close the connection after a request.

check_fastcgi_param

    Syntax: *check_fastcgi_params parameter value*

    default: see below

    context: *upstream*

    description: If you set the check type is fastcgi, then the check
    function will sends this fastcgi headers to check the upstream server.
    The default directive looks like:

            check_fastcgi_param "REQUEST_METHOD" "GET";
            check_fastcgi_param "REQUEST_URI" "/";
            check_fastcgi_param "SCRIPT_FILENAME" "index.php";

check_shm_size

    syntax: *check_shm_size size*

    default: *1M*

    context: *http*

    description: Default size is one megabytes. If you check thousands of
    servers, the shared memory for health check may be not enough, you can
    enlarge it with this directive.